<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<meta name="viewport" content="maximum-scale=1.0,minimum-scale=1.0,user-scalable=0,width=device-width,initial-scale=1.0"/>
		<meta name="format-detection" content="telephone=no,email=no,date=no,address=no">
		<title>上网明细</title>
		<link rel="stylesheet" type="text/css" href="../css/api.css"/>
		<link rel="stylesheet" type="text/css" href="../css/common.css"/>
		<style>
			body {
				padding: 20px 15px 0;
			}
			.list-view > li:nth-last-child(1) .y-cutline {
				display: none;
			}
			.bill-details-item {
				height: 89px;
			}
			.left-content {
				text-align: right;
				width: 40px;
			}
			.cut-content {
				margin: 0px 15px 0;
			}
			.origin {
				height: 10px;
				width: 10px;
				border-radius: 50%;
			}
			/* 奇数颜色 */
			.origin.first {
				background-color: #ffb6a9;
			}
			/* 偶数 */
			.origin.second {
				background-color: #54b3f9;
			}
			/* 年的颜色 */
			.origin.thread {
				background-color: #70d2bc;
			}
			.line {
				background-color: #e6e6e6;
				width: 1px;
				height: 79px;
				margin-left: 4.5px;
			}
			.font1 {
				color: #989898;
				font-size: 12px;
			}
			.font2 {
				color: #555;
				font-size: 15px;
			}
			.font3 {
				color: #989898;
				font-size: 14px;
			}
			.font4 {
				color: #101010;
				font-size: 17px;
			}
			.font5 {
				color: #ff8000;
				font-size: 15px;
			}
			.bill-details-item .line2 {
				background-color: #e6e6e6;
				width: 1px;
				height: 10px;
				margin: 5px 0 5px 20px;
			}
			.bill-details-item .time-hm-start {
				margin-top: 14px;
			}
			.bill-details-item .time-sur {
				margin-top: 15px;
			}
			/*年之间的分割线*/
			.line3 {
				height: 24px;
			}
			.details-item-y {
			}
			/* 加载更多---------start */
			.load-more-content {
				height: 128px;
				width: 100%;
				line-height: 128px;
				text-align: center;
			}
			.load-more-content > img {
				height: 20px;
				width: 20px;
				vertical-align: middle;
			}
			.load-more-content > span {
				margin-left: 15px;
				color: #bfbfbf;
				font-size: 14px;
			}
			/* 加载更多---------end */
		</style>
	</head>
	<body>
		<!-- 子listview的item模板 -->
		<div id="sub-listview-item-temp" style="display: none;">
			<div class="flex-between">
				<div class="left-content">
					<div class="time-md font2">
						05.21
					</div>
					<div class="time-hm-start font1">
						14:20
					</div>
					<div class="line2"></div>
					<div class="time-hm-end font1">
						15:20
					</div>
				</div>
				<div class="cut-content">
					<div class="origin first"></div>
					<div class="line"></div>
				</div>
				<div>
					<div class="time-all font4">
						01:00
					</div>
					<div class="time-sur font5">
						剩余42:54
					</div>
				</div>
			</div>
			<div>
				<div class="net-place">
					星巴克(深圳学府路店)
				</div>
			</div>
		</div>
		<!--父listview的item的模板-->
		<div id="listview-item-temp" style="display: none;">
			<ul class="sub-list-view"></ul>
			<div class="flex-start">
				<div class="font4 details-item-y left-content">
					2017
				</div>
				<div class="cut-content ">
					<div class="origin thread"></div>
					<div class="y-cutline line line3"></div>
				</div>
			</div>
		</div>
		<ul class="list-view"></ul>
	</body>
	<script type="text/javascript" src="../script/api.js"></script>
	<script type="text/javascript" src="../script/common.js"></script>
	<script type="text/javascript" src="../script/md5.js"></script>
	<script type="text/javascript" src="../script/request.js"></script>
	<script type="text/javascript">
		var mUrl = 'http://l139.199.72.236:8080/proxyservice/TransferServlet';
		var mListViewIndex;
		var mSubListViewIndex;
		var mListView;
		var mListDatas;
		var mIsLoadMore = false;
		var mToken, mUserid;
		var mPageSize = 20;
		var mPageNum = 1;
		//服务器总页数
		var mPageCount = 0;
		apiready = function() {
			initData();
			initView();
			requestNetDetails(mToken, mUserid, mPageSize, mPageNum);
		};
		function initView() {
			mListView = document.getElementsByClassName('list-view')[0];
		}

		function initData() {
			mToken = api.pageParam.token;
			mUserid = api.pageParam.userid;
			mUrl = api.pageParam.url;
			mPageSize = 20;
			mPageNum = 1;
		}

		function skipToNetDetaisWin(data) {
			api.openWin({
				name : 'details',
				url : './details.html',
				pageParam : data
			});
		}

		/**
		 * 请求上网明细接口
		 * @param {String} token - app token
		 * @param {String} userid - userid
		 * @param {int} pageSize - 每页显示的数据条数
		 * @param {int} pageNum - 第几页
		 */
		function requestNetDetails(token, userid, pageSize, pageNum) {
			console.log('requestNetDetails-----token, userid, pageSize, pageNum===' + token + ',' + userid + ',' + pageSize + ',' + pageNum);
			if (!mIsLoadMore) {
				api.showProgress({
				});
			}
			var params = {
				'userid' : userid,
				'pageSize' : pageSize,
				'pageNum' : pageNum
			};
			var keyword = 'map_netInfoList';
			var ps = MyRequest.createParam(params, token, userid, keyword);
			MyRequest.requestMethod(mUrl, ps, function(result) {
				console.log('requestNetDetails---result=' + JSON.stringify(result));
				if (!mIsLoadMore) {
					api.hideProgress();
				}
				analyzeRequestResponse(result);
			}, 'requestNetDetails');
		}

		/**
		 * 分析请求返回的数据
		 */
		function analyzeRequestResponse(result) {
			if (!result) {
				api.toast({
					msg : '连接服务器失败。'
				});
				if (mIsLoadMore) {
					//加载失败，页数不变。
					loadMoreTip(true);
				}
			} else {
				var code = result.code;
				mPageCount = result.pageCount;
				var datas = result.infos;
				if (code == 0) {
					api.toast({
						msg : '失败'
					});
					if (mIsLoadMore) {
						//加载失败，页数不变。
						loadMoreTip(true);
					}
				} else if (code == 1) {
					datas = dealDatas(datas);
					if (mIsLoadMore) {
						//加载更多
						loadMoreListView(datas, dealMoreDatas(datas));
					} else {
						mListDatas = datas;
						//初始化展示
						initListView(datas);
					}
				} else {
					api.toast({
						msg : '异常'
					});
					if (mIsLoadMore) {
						//加载失败，页数不变。
						loadMoreTip(true);
					}
				}
			}
		}

		/**
		 * 处理数据，生成可用的数据 。
		 */
		function dealDatas(datas) {
			console.log('dealDatas---' + JSON.stringify(datas));
			//过滤垃圾数据
			var fData = filterDatas(datas);
			//将数据的日期转换成兼容模式
			fData= convertTime(fData);
			console.log('fData---' + JSON.stringify(fData));
			//填充数据 (如果结束时间是空的，将结束时间补充)
			var sData = fillTimeDatas(fData);
			console.log('sData---' + JSON.stringify(sData));
			//根据上网开始时间和上网时长，算出结束时间。
			var endData = calEndTime(sData);
			console.log('endData---' + JSON.stringify(endData));
			//将时间格式改为ios和android通用格式
			var gData = convertTime(endData);
			console.log('gData---' + JSON.stringify(gData));
			//检查每个数据的开始时间和结束时间，判断是否跨天。是，将数据分开，然后替换原数据。反之，不做处理。(都要转换数据格式)
			var aDatas = partDatas(gData);
			console.log('aDatas----' + JSON.stringify(aDatas));
			//区分年,检查每个数据的年是是否和前一个数据的年相同，
			var bDatas = diffYear(datas);
			console.log('bDatas----' + JSON.stringify(bDatas));
			return bDatas;
		}

		/**
		 * 处理加载更多得到的数据
		 * @return true==有相同年的数据，显示view时需要特殊处理;
		 */
		function dealMoreDatas(datas) {
			var isSame = false;
			//判断datas第一个数据的年是否和总数据mListDatas的最后一个数据的年是否相同
			//相同，就将第一个年数据加入到最后一个年数据中，其它的数据就直接从总数据最后一年数据开始添加
			var moreFirstYDatas = datas[0];
			var moreFirstY = moreFirstYDatas.y;
			var sumLastYDatas = mListDatas[mListDatas.length - 1];
			var sumLastY = sumLastYDatas.y;
			var j = 0;
			if (moreFirstY == sumLastY) {
				isSame = true;
				for (var i = 0; i < moreFirstYDatas.datas.length; i++) {
					mListDatas[mListDatas.length - 1].datas.push(moreFirstYDatas.datas[i]);
				}
				j = 1;
			} else {
				j = 0
			}
			for (; j < datas.length; j++) {
				mListDatas.push(datas[j]);
			}
			return isSame;
		}


		Date.prototype.Format = function(fmt) {//author: meizz
			var o = {
				"M+" : this.getMonth() + 1, //月份
				"d+" : this.getDate(), //日
				"h+" : this.getHours(), //小时
				"m+" : this.getMinutes(), //分
				"s+" : this.getSeconds(), //秒
				"q+" : Math.floor((this.getMonth() + 3) / 3), //季度
				"S" : this.getMilliseconds() //毫秒
			};
			if (/(y+)/.test(fmt))
				fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
			for (var k in o)
			if (new RegExp("(" + k + ")").test(fmt))
				fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
			return fmt;
		}
		/**
		 * 过滤垃圾数据
		 */
		function filterDatas(datas) {
			var data;
			for (var i = 0; i < datas.length; i++) {
				data = datas[i];
				if (data.longTime == null) {
					datas.splice(i, 1);
					i -= 1;
				}
			}
			return datas;
		}

		/**
		 * 根据上网开始时间和上网时长，算出结束时间。
		 */
		function calEndTime(datas) {
			var dl = datas.length;
			var data;
			for (var i = 0; i < dl; i++) {
				data = datas[i];
				//计算结束时间（根据开始时间和持续时间相加）
				data.outNetTime = new Date(new Date(data.getNetTime).getTime() + data.netTime * 60 * 1000).Format("yyyy-MM-dd hh:mm:ss");
			}
			return datas;
		}

		/**
		 * 将时间格式改为ios和android通用格式
		 */
		function convertTime(datas) {
			var data;
			for (var i = 0; i < datas.length; i++) {
				data = datas[i];
				if (data.getNetTime != '' && data.getNetTime != null) {
					data.getNetTime = data.getNetTime.replace(/-/g, "/");
				}
				if (data.outNetTime != '' && data.outNetTime != null) {
					data.outNetTime = data.outNetTime.replace(/-/g, "/");
				}
			}
			return datas;
		}

		/**
		 * 填充数据 (如果结束时间是空的，将结束时间补充)
		 */
		function fillTimeDatas(datas) {
			var dl = datas.length;
			var data;
			for (var i = 0; i < dl; i++) {
				data = datas[i];
				if (data.outNetTime == '') {
					//计算结束时间（根据开始时间和持续时间相加）
					data.outNetTime = new Date(new Date(data.getNetTime).getTime() + data.netTime * 60 * 1000).Format("yyyy-MM-dd hh:mm:ss");
				}
			}
			return datas;
		}

		/**
		 * 检查每个数据的开始时间和结束时间，判断是否跨天。是，将数据分开，然后替换原数据。反之，不做处理。(都要转换数据格式)(兼容跨月，跨年)。
		 * {
		 * 		'sur_time' : 1, //剩余时长'01:10'
		 * 		'continue_time' : 1, //持续时长'01:15'
		 * 		'md' : '', //日期'01:20'月日
		 * 		'y' : '', //年
		 * 		's_time' : '', //开始时间'01:01'时分
		 * 		'e_time' : '', //结束时间'01:01'时分
		 * 		'getNetmap' : "深大",
		 * 		'outNetmap' : "深大"
		 * }
		 */
		function partDatas(datas) {
			var dl = datas.length;
			//起始index
			var i = 0;
			//开始时间对象
			var st;
			var stY;
			var stM;
			var stD;
			var stH;
			var stMi;
			var stS;
			//结束时间对象
			var et;
			var etY;
			var etM;
			var etD;
			var etH;
			var etMi;
			var etS;
			//单条数据
			var data;
			//临时数据
			var data1;
			var data2;
			//剩余时间
			var longTime1;
			//持续时间
			var netTime1;
			var getNetTime1;
			var outNetTime1;
			var longTime2;
			var netTime2;
			var getNetTime2;
			var outNetTime2;
			for (; i < datas.length; i++) {
				data = datas[i];
				st = new Date(data.getNetTime);
				et = new Date(data.outNetTime);
				stD = st.getDate();
				stY = st.getFullYear();
				stM = st.getMonth() + 1;
				stH = st.getHours();
				stMi = st.getMinutes();
				stS = st.getSeconds();
				etD = et.getDate();
				etY = et.getFullYear();
				etM = et.getMonth() + 1;
				etH = et.getHours();
				etMi = et.getMinutes();
				etS = et.getSeconds();
				//如果是当天，数据修改成特殊格式数据。
				if (stD == etD && stY == etY && stM == etM) {
					data1 = null;
					data1 = {
						//剩余时长'01:10'
						'sur_time' : fomatTime(parseInt(data.longTime / 60)) + ':' + fomatTime(data.longTime % 60),
						//剩余时长'01:10'
						'continue_time' : fomatTime(parseInt(data.netTime / 60)) + ':' + fomatTime(data.netTime % 60),
						'md' : fomatTime(stM) + '.' + fomatTime(stD), //日期'01.20'月日
						'y' : stY, //年
						's_time' : fomatTime(stH) + ':' + fomatTime(stMi), //开始时间'01:01'时分
						'e_time' : fomatTime(etH) + ':' + fomatTime(etMi), //结束时间'01:01'时分
						'getNetmap' : data.getNetmap,
						'outNetmap' : data.outNetmap
					};
					//替换数据
					datas.splice(i, 1, data1);
				} else {//如果跨天,将数据按天分开，替换原数据
					i = strideDayMethod(st, et, i, datas);
				}
			}
			return datas;
		}

		/**
		 * 跨天的逻辑处理
		 * @param {Date} st - Date对象（开始时间）
		 * @param {Date} et - Date对象（结束时间）
		 * @param {Object} data - 当前数据对象
		 * @param {Array} datas - 当前数据数组
		 * return 返回index
		 */
		function strideDayMethod(st, et, index, datas) {
			var data = datas[index];
			//剩余时长
			var surTime;
			//上网时长
			var netTime;
			//开始时间
			var stTime;
			//结束时间
			var edTime;
			//年
			var year;
			//月日
			var md;
			var timeInterval = et.getTime() - st.getTime();
			var i = 0;
			//开始时间23点59分59秒时的时间
			var s0 = new Date(st.getFullYear() + '/' + (st.getMonth() + 1) + '/' + st.getDate() + ' ' + '23:59:59');
			//当天零点的时间毫秒数
			var zeroTime = s0.getTime();
			//结束时间的零点时间
			var e0 = new Date(et.getFullYear() + '/' + (et.getMonth() + 1) + '/' + et.getDate() + ' ' + '00:00:00');
			//结束时间当天的零点的毫秒数
			var endZeroTime = e0.getTime();
			//中间天的23点59分59秒时的时间
			var z0;
			//计算总时间间隔-（当天零点-当天开始时间）的间隔，以便得到时间一共经历了几天。
			var count = parseInt((timeInterval - (zeroTime - st.getTime())) / 1000 - 24 * 60 * 60);
			//是否时间间隔大于1秒，是，大于2天，否，只有两天。
			count > 1 ? count = parseInt((e0.getTime() - s0.getTime()) / (24 * 1000 * 60 * 60)) + 2 : count = 2;
			var data1;
			for (; i < count; i++) {
				if (i == 0) {//第一天,分钟
					//剩余时间=总剩余时间+（结束时间-第一天23:59:59时间）
					surTime = data.longTime + parseInt((et.getTime() - zeroTime) / (1000 * 60));
					//得到小时和分钟的结合。
					surTime = fomatTime(parseInt(surTime / 60)) + ':' + fomatTime(surTime % 60);
					//上网时长=第一天23:59:59时间-开始时间
					netTime = fomatTime(parseInt((zeroTime - st.getTime()) / (1000 * 60 * 60))) + ':' + fomatTime((parseInt((zeroTime - st.getTime()) / (1000 * 60))) % 60);
					stTime = fomatTime(st.getHours()) + ':' + fomatTime(st.getMinutes());
					edTime = '23:59';
					year = st.getFullYear();
					md = fomatTime(st.getMonth() + 1) + '.' + fomatTime(st.getDate());
				} else if (i == count - 1) {//最后一天
					//剩余时间=总剩余时间
					surTime = fomatTime(parseInt(data.longTime / 60)) + ':' + fomatTime(data.longTime % 60);
					//上网时长=结束时间-结束时间的零点的时间
					netTime = fomatTime(parseInt((et.getTime() - endZeroTime) / (1000 * 60 * 60))) + ':' + fomatTime((parseInt((et.getTime() - endZeroTime) / (1000 * 60))) % 60);
					stTime = '00:00';
					edTime = fomatTime(et.getHours()) + ':' + fomatTime(et.getMinutes());
					year = et.getFullYear();
					md = fomatTime(et.getMonth() + 1) + '.' + fomatTime(et.getDate());
				} else {//中间天
					//剩余时间=总剩余时间+(结束时间-这天的23:59:59的时间);
					z0 = s0.getTime() + (24 * 60 * 60 * 1000 * (i));
					surTime = data.longTime + parseInt((et.getTime() - z0) / (1000 * 60));
					surTime = fomatTime(parseInt(surTime / 60)) + ':' + fomatTime(surTime % 60);
					//上网时长=24小时
					netTime = '23:59';
					stTime = '00:00';
					edTime = '23:59';
					z0 = new Date(z0);
					year = z0.getFullYear();
					md = fomatTime(z0.getMonth() + 1) + '.' + fomatTime(z0.getDate());
				}
				data1 = {
					'sur_time' : surTime,
					'continue_time' : netTime,
					'md' : md,
					'y' : year,
					's_time' : stTime,
					'e_time' : edTime,
					'getNetmap' : data.getNetmap,
					'outNetmap' : data.outNetmap
				};
				if (i == 0) {
					//替换数据
					datas.splice(index, 1, data1);
				} else {
					//添加数据
					datas.splice(index, 0, data1);
				}
			}
			index = index + count - 1;
			return index;
		}

		/**
		 * 区分年
		 * 检查每个数据的年是是否和前一个数据的年相同，
		 * 相同，就添加数据
		 * 不相同，就新建object，添加数据
		 */
		function diffYear(datas) {
			//容器
			var vessel = [];
			//年的容器
			var vessel2 = {
				'y' : 0,
				'datas' : []
			};
			var dl = datas.length;
			var i = 0;
			var y;
			var data;
			for (; i < dl; i++) {
				data = datas[i];
				if (i == 0) {
					y = data.y;
					vessel2.y = y;
					vessel2.datas.push(data);
					//新装一个obj
					vessel.push(vessel2);
				} else {
					if (data.y != datas[i - 1].y) {
						y = data.y;
						//重新初始化
						vessel2 = {
							'y' : 0,
							'datas' : []
						};
						vessel2.y = y;
						vessel2.datas.push(data);
						//新装一个obj
						vessel.push(vessel2);
					} else {
						y = data.y;
						vessel2.y = y;
						vessel2.datas.push(data);
					}
				}
			}
			return vessel;
		}

		/**
		 * 格式化时间
		 */
		function fomatTime(time) {
			if (time < 10) {
				time = '0' + time;
			}
			return time;
		}

		/**
		 * 初始化展示listview
		 */
		function initListView(datas) {
			if (mListView != null) {
				mListView.innerHTML = '';
			}
			//年数
			var yl = datas.length;
			var i = 0;
			var li;
			//每年的数据
			for (; i < yl; i++) {
				li = createItem(datas[i]);
				mListView.appendChild(li);
			}
			listenerScrollBottom();
		}

		/**
		 * 创建listview的item
		 * @param {json} datas - 多年的总数据
		 */
		function createItem(datas) {
			var li = document.createElement('li');
			li.className = 'list-view-item';
			li.innerHTML = document.getElementById('listview-item-temp').innerHTML;
			var yCutline = li.getElementsByClassName('y-cutline')[0];
			var y = li.getElementsByClassName('details-item-y')[0];
			var yUl = li.getElementsByClassName('sub-list-view')[0];
			y.innerText = datas.y;
			var subDatas = datas.datas;
			for (var i = 0; i < subDatas.length; i++) {
				var subData = subDatas[i];
				var subLi = createSubItem(subData, i);
				yUl.appendChild(subLi);
			}
			return li;
		}

		/**
		 * 创建sub-listview的item
		 * @param {json} data - json数据(每年的数据)
		 * @param {int} index - li的index
		 */
		function createSubItem(data, index) {
			var li = document.createElement('li');
			li.className = 'sub-list-view-item bill-details-item flex-between';
			li.innerHTML = document.getElementById('sub-listview-item-temp').innerHTML;
			//月日
			var md = li.getElementsByClassName('time-md')[0];
			//开始时间
			var startT = li.getElementsByClassName('time-hm-start')[0];
			//结束时间
			var endT = li.getElementsByClassName('time-hm-end')[0];
			//持续时间
			var conT = li.getElementsByClassName('time-all')[0];
			//剩余时间
			var surT = li.getElementsByClassName('time-sur')[0];
			//地点
			var place = li.getElementsByClassName('net-place')[0];
			//原点
			var origin = li.getElementsByClassName('origin')[0];
			if (index % 2 == 0) {
				origin.className = 'origin first';
			} else {
				origin.className = 'origin second';
			}
			place.innerText = comJs.dataFaultTolerant(data.getNetmap);
			md.innerText = comJs.dataFaultTolerant(data.md);
			startT.innerText = comJs.dataFaultTolerant(data.s_time);
			endT.innerText = comJs.dataFaultTolerant(data.e_time);
			conT.innerText = comJs.dataFaultTolerant(data.continue_time);
			surT.innerText = '剩余' + comJs.dataFaultTolerant(data.sur_time);
			li.onclick = function() {
				var lis = mListView.getElementsByClassName('list-view-item');
				var lisLen = lis.length;
				var i;
				var j;
				var subLis;
				var subLisLen;
				for ( i = 0; i < lisLen; i++) {
					subLis = lis[i].getElementsByClassName('sub-list-view-item');
					subLisLen = subLis.length;
					for ( j = 0; j < subLisLen; j++) {
						if (this == subLis[j]) {
							mListViewIndex = i;
							mSubListViewIndex = j;
							break;
						}
					}
				}
				skipToNetDetaisWin(mListDatas[mListViewIndex].datas[mSubListViewIndex]);
				console.log('---------mListViewIndex=' + mListViewIndex + '   mSubListViewIndex=' + mSubListViewIndex);
			}
			return li;
		}

		/**
		 * 加载更多的失败提示以及处理方法
		 * @param {Boolean} isFailure - 是否是失败了，是，不提示；否，提示没有更多数据。
		 */
		function loadMoreTip(isFailure) {
			//加载失败，页数不变。
			mPageNum--;
			if (!isFailure) {
				api.toast({
					msg : '没有更多数据了'
				});
			} else {
				api.toast({
					msg : '加载更多失败。'
				});
			}
			mIsLoadMore = false;
			hideLoadMoreView();
		}

		/**
		 * 加载更多，数据需要处理---------------------------------??????
		 * @param {json} datas - 加载更多得到的数据（处理后的）
		 * @param {boolean} isSame - 是否有相同年的数据，有的话，就要对之前的view的最后一个sublistview追加li
		 */
		function loadMoreListView(datas, isSame) {
			console.log('loadMoreListView---mListDatas=' + JSON.stringify(mListDatas));
			//判断datas第一个数据的年是否和总数据mListDatas的最后一个数据的年是否相同
			//相同，就将第一个年数据加入到最后一个年view中，其它的数据就直接从总数据最后一年view开始添加
			var moreFirstYDatas = datas[0];
			var moreFirstY = moreFirstYDatas.y;
			var lis;
			var lisLen;
			var lastsubUl;
			var subLi;
			var subLis;
			var subLisLen;
			var newLi;
			var j = 0;
			if (isSame) {
				for (var i = 0; i < moreFirstYDatas.datas.length; i++) {
					lis = mListView.getElementsByClassName('list-view-item');
					lisLen = lis.length;
					lastsubUl = lis[lisLen-1].getElementsByClassName('sub-list-view')[0];
					lastsubLis = lastsubUl.getElementsByClassName('sub-list-view-item');
					lastsubLisLen = lastsubLis.length;
					lastsubLi = createSubItem(moreFirstYDatas.datas[i], lastsubLisLen);
					lastsubUl.appendChild(lastsubLi);
				}
				//已经使用了datas的index==0的数据，那么加载其它数据就从1开始
				j = 1;
			} else {
				j = 0;
			}
			//加载其它的不同年的数据
			for (; j < datas.length; j++) {
				newLi = createItem(datas[j]);
				mListView.appendChild(newLi);
			}
			//加载完成之后，还原数据
			mIsLoadMore = false;
			hideLoadMoreView();
		}

		/**
		 * 隐藏“加载更多”的view
		 */
		function hideLoadMoreView() {
			var loadViews = document.getElementsByClassName('load-more-content');
			if (loadViews.length != 0) {
				document.getElementsByTagName('body')[0].removeChild(loadViews[0]);
			}
		}

		/**
		 * 展示“加载更多”的view
		 */
		function showLoadMoreView() {
			var loadView = document.createElement('div');
			loadView.className = 'load-more-content';
			loadView.innerHTML = '<img src="../image/icon_loading.png" /><span>加载中</span>';
			document.getElementsByTagName('body')[0].appendChild(loadView);
		}

		//设置“滑动到底部”事件监听
		function listenerScrollBottom() {
			api.addEventListener({
				name : 'scrolltobottom',
				extra : {
					threshold : 0 //设置距离底部多少距离时触发，默认值为0，数字类型
				}
			}, function(ret, err) {
				//判断列表是否已经到达屏幕底部，是，就代表可以加载更多；否，就不让加载更多。+判断服务器数据是否为最后一页
				if (mListView.offsetHeight >= api.frameHeight && !mIsLoadMore && (mPageNum < mPageCount)) {
					mIsLoadMore = true;
					showLoadMoreView();
					requestNetDetails(mToken, mUserid, mPageSize, ++mPageNum)
				}
			});
		}
	</script>
</html>